package com.juai.centralkitchen.speechsynthesis;

/**
 * @ClassName TtsSyntherizer
 * @Description TODO消息
 * @Author biekangdong
 * @CreateDate 2021/5/13 23:34
 * @Version 1.0
 * @UpdateDate 2021/5/13 23:34
 * @UpdateRemark 更新说明
 *
 */

import android.content.Context;
import android.util.Log;

import com.baidu.tts.chainofresponsibility.logger.LoggerProxy;
import com.baidu.tts.client.SpeechError;
import com.baidu.tts.client.SpeechSynthesizer;
import com.baidu.tts.client.SpeechSynthesizerListener;
import com.baidu.tts.client.TtsMode;

import java.util.ArrayList;
import java.util.List;

/**
 * 百度语音合成 在线TTS
 *
 * 播放 ：立即播报
 *       排在正在播放的下一个
 *       排在播放列表的最后
 *
 * 暂停 ： 立即暂停
 *        播报完成当前语音再暂停
 *
 * 停止 ： 立即停止
 *        播报完成当前语音再停止
 *
 * 恢复播放 ： 若当前播报未完成，继续播报当前语音 否则播报队列中的；
 *
 * 可以获取当前播报状态
 *
 */

public class TtsSyntherizer {
    private static final String TAG = "TtsSyntherizer";
    public static TtsSyntherizer ttsSyntherizer;

    private static Context mContext;
    private  static SpeechSynthesizer mSpeechSynthesizer;

    public static TtsSyntherizer getInstance(Context context){
        if(ttsSyntherizer==null){
            ttsSyntherizer=new TtsSyntherizer();
             mContext = context;
             initTTs();
        }
        return ttsSyntherizer;
    }

    private static   volatile boolean isInitTts = false;
    /**
     * 初始化语音播报
     */
    public static void initTTs() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                if (AppConfig.IS_DEV) LoggerProxy.printable(true); // 日志打印在logcat中
                // 1. 获取实例
                mSpeechSynthesizer = SpeechSynthesizer.getInstance();
                mSpeechSynthesizer.setContext(mContext);
                // 2. 设置listener
                mSpeechSynthesizer.setSpeechSynthesizerListener(speechSynthesizerListener);

                // 3. 设置appId，appKey.secretKey
                mSpeechSynthesizer.setAppId(AppConfig.BaiduTTSAppId);
                mSpeechSynthesizer.setApiKey(AppConfig.BaiduTTSAppKey, AppConfig.BaiduTTSSecretKey);

                // 5. 以下setParam 参数选填。不填写则默认值生效
                // 设置在线发声音人： 0 普通女声（默认） 1 普通男声 2 特别男声 3 情感男声<度逍遥> 4 情感儿童声<度丫丫>
                mSpeechSynthesizer.setParam(SpeechSynthesizer.PARAM_SPEAKER, "0");
                // 设置合成的音量，0-15 ，默认 5
                mSpeechSynthesizer.setParam(SpeechSynthesizer.PARAM_VOLUME, "15");
                // 设置合成的语速，0-15 ，默认 5
                mSpeechSynthesizer.setParam(SpeechSynthesizer.PARAM_SPEED, "5");
                // 设置合成的语调，0-15 ，默认 5
                mSpeechSynthesizer.setParam(SpeechSynthesizer.PARAM_PITCH, "5");
                mSpeechSynthesizer.setParam(SpeechSynthesizer.PARAM_MIX_MODE, SpeechSynthesizer.MIX_MODE_DEFAULT);
                // 该参数设置为TtsMode.MIX生效。即纯在线模式不生效。
                // 6. 初始化
                int result = mSpeechSynthesizer.initTts(TtsMode.ONLINE);
                if (result == 0) {
                    isInitTts = true;
                } else {
                    isInitTts = false;
                }
            }
        }).start();
    }
    static SpeechSynthesizerListener speechSynthesizerListener=new SpeechSynthesizerListener() {
        @Override
        public void onSynthesizeStart(String s) {
            Log.e(TAG, "onSynthesizeStart: " );
        }

        @Override
        public void onSynthesizeDataArrived(String s, byte[] bytes, int i, int i1) {
            Log.e(TAG, "onSynthesizeDataArrived: " );
        }

        @Override
        public void onSynthesizeFinish(String s) {
            Log.e(TAG, "onSynthesizeFinish: " );
        }

        @Override
        public void onSpeechStart(String s) {
            Log.e(TAG, "onSpeechStart: " );
            ttsState = TtsStateEnum.PLAY;
        }

        @Override
        public void onSpeechProgressChanged(String s, int i) {
            Log.e(TAG, "onSpeechProgressChanged: " );
        }

        @Override
        public void onSpeechFinish(String s) {
            Log.e(TAG, "onSpeechFinish: " );
            if (ttsPlayDatas!=null&&ttsPlayDatas.size()>0 && ttsState == TtsStateEnum.PLAY){
                //如果当前播放列表中有数据，并且不是暂停状态或停止状态
                ttsSpeak(ttsPlayDatas.get(0));
                ttsPlayDatas.remove(0);
            }
            Log.e(TAG, "播放结束: " );
            ttsState = TtsStateEnum.LDLE;
        }

        @Override
        public void onError(String s, SpeechError speechError) {
            Log.e(TAG, "onError: " );
        }
    };

    private static TtsStateEnum ttsState = TtsStateEnum.LDLE; //默认是空闲状态
    private static List<String> ttsPlayDatas; //语音播报列表

    /**
     * 开始语音播报
     * @param text 播报内容
     * @param code 1 代表立即播报
     *             2 排在正在播放的下一个
     *             3 排在最后
     * @param isClearQueue 是否播放完本条内容后清空队列停止播报
     * @return
     */
    public int ttsSpeak(String text , int code , boolean isClearQueue) {
        if (mSpeechSynthesizer != null && isInitTts){
            int result = 0;
            if (ttsPlayDatas == null)ttsPlayDatas = new ArrayList<>();
            switch (code){
                case 1: //立即播报
                    if (ttsState != TtsStateEnum.LDLE)ttsStop(true);
                    ttsSpeak(text);
                    break;
                case 2: //排在正在播放的下一个
                    if (ttsState != TtsStateEnum.LDLE) {
                        ttsPlayDatas.add(0, text);
                    }else {
                        ttsSpeak(text);
                    }
                    break;
                case 3:
                    if (ttsState != TtsStateEnum.LDLE) {
                        ttsPlayDatas.add(text);
                    }else {
                        ttsSpeak(text);
                    }
                    break;
            }
            if (isClearQueue) ttsPlayDatas.clear();
            return result;

        }else {
            return 1;
        }
    }

    /**
     * 默认开始播放
     * @param text
     * @return
     */
    public static int ttsSpeak(String text) {
        if (AppConfig.IS_OFF_TTS_PLAY){
            return 2; //已经关闭语音播报开关
        }
        if (mSpeechSynthesizer != null && isInitTts){
            int result = mSpeechSynthesizer.speak(text);
            return result;
        }else {
            return 1;
        }
    }

    /**
     * 暂停语音播报
     *  @parem afterCurrent 是否立即暂停
     * @return 0 是成功
     */
    public int ttsPause(boolean afterCurrent) {
        if (mSpeechSynthesizer != null && isInitTts){
            if (afterCurrent){ //立即暂停
                int result = mSpeechSynthesizer.pause();
                ttsState = TtsStateEnum.PAUSE;
                return result;
            }else { //播放完当前语音再暂停
                ttsState = TtsStateEnum.PAUSE;
                return 0;
            }

        }else {
            return 1;
        }
    }

    /**
     * 恢复语音播报
     * @return 0 是成功
     */
    public int ttsResume() {
        if (mSpeechSynthesizer != null && isInitTts){
            if (ttsState == TtsStateEnum.PAUSE){ //如果是暂停状态，就恢复播放
                int result = mSpeechSynthesizer.resume();
                ttsState = TtsStateEnum.PLAY;
                return result;
            }else { //如果不是暂停状态
                if (ttsPlayDatas!=null&&ttsPlayDatas.size()>0 && ttsState == TtsStateEnum.LDLE){
                    ttsSpeak(ttsPlayDatas.get(0));
                }
                return 0;
            }
        }else {
            return -1;
        }
    }

    /**
     *  停止语音播报
     *  @parem afterCurrent 是否立即暂停
     * @return 0是成功
     */
    public int ttsStop(boolean afterCurrent) {
        if (mSpeechSynthesizer != null && isInitTts){
            if (ttsPlayDatas != null) ttsPlayDatas.clear();
            if (afterCurrent){ //立即停止播报
                int result = mSpeechSynthesizer.stop();
                ttsState = TtsStateEnum.LDLE;
                return result;
            }else { //当前播报完成再停止
                ttsState = TtsStateEnum.LDLE;
                return 0;
            }
        }else {
            return 1;
        }
    }


    /**
     *  获取TTS状态
     * @return 0是成功
     */
    public TtsStateEnum getTtsState() {
        if (mSpeechSynthesizer != null && isInitTts){
            return ttsState;
        }else {
            return TtsStateEnum.LDLE;
        }
    }

    /**
     * 释放TTS资源
     */
    public void release() {
        if (mSpeechSynthesizer != null){
            mSpeechSynthesizer.stop();
            mSpeechSynthesizer.release();
            isInitTts = false;
            ttsState = TtsStateEnum.LDLE;
            ttsPlayDatas = null;
            mSpeechSynthesizer = null;
        }
    }

}
